package utilities;


import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import javax.naming.*;
import javax.sql.*;
import java.sql.*;
import java.util.*;

/**
 * Created with IntelliJ IDEA.
 * User: Jordi
 * Date: 3/01/13
 * Time: 17:41
 * To change this template use File | Settings | File Templates.
 */
public class Utilitats extends Object implements java.io.Serializable, Cloneable {

    public static final char NONE = 'N';
    public static final char ROLLBACK = 'R';
    public static final char COMMIT = 'C';
    protected boolean conexionCerrada = false;
    protected transient Context context;
    protected transient DataSource dataSource;
    protected transient Connection connection;
    protected transient Statement statement;
    protected transient PreparedStatement preparedStatement;
    protected transient CallableStatement callStatement = null;
    protected transient ResultSet resultSet;
    protected Properties conexionProperties = null;
    protected String nombreOrigenDatos = null;
    protected String nombreCursor = null;
    protected int maxLongitudCampo = 0;
    protected int maxFilas = 0;
    protected int queryTiempoLimite = 0;
    protected int fetchDireccion = 0;
    protected int fetchLongitud = 0;
    //TYPE_FORWARD_ONLY = 1003, TYPE_SCROLL_INSENSITIVE = 1004, TYPE_SCROLL_SENSITIVE = 1005
    protected int resultadoSetType = ResultSet.TYPE_FORWARD_ONLY;
    //CONCUR_READ_ONLY, CONCUR_UPDATABLE
    protected int concurrencia = ResultSet.CONCUR_READ_ONLY;
    protected boolean soloLectura = false;
    protected boolean cerrarStatementTrasEjecucion = true;
    protected boolean escapeProcessing = true;
    protected boolean transaccionEnCurso = false;
    protected boolean resetOrigenDatos = false;
    protected boolean debug = false;
    protected boolean advertenciasProcesadas = false;
    protected boolean proccessStoredProc = false;
    protected boolean cerrarResultSet = true;
    protected char proccessTransactionOnCloseConnection = NONE;
    protected int maxFilasProcesarTransaccion = 0; // cuantas filas para to update/insert/delete en la transacción
    protected int filasAfectadasPorTransaccion = 0;
    protected String conexionId = "<none>";
    protected String marcadorPosicion = null;
    protected int numeroMaximoParametros = -1;
    protected transient List resultSets = null;
    protected List advertencias = null;
    //indicadores de cómo manejar ResultSet(s) desde Stored Procedures y Functions
    public static final int IGNORAR_RESULTADO = 0; // no procesar ResultSet(s)
    public static final int RESULTADO_LISTA_CONTENEDOR_DATOS = 1;
    public static final int RESULTADO_VECTOR = 2; // Vector de vectores
    public static final int RESULTADO_MAP = 3; // Map of Lists
    public static final int RESULTADO_ROWSET = 4; // CachedRowSetImpl
    protected boolean almacenStatements = false;
    protected int maxLongitudAlmacenamientoSentencias = 20; // se debe porner antes del inicio de sentenciasAlmacenamiento, por defecto: 20
    protected List sentenciasId; // id de sentencias almacenadas (sql String)
    protected List sentenciasAlmacenamiento; // sentencias almacenadas
    protected List contadorSentenciasAlmacenadas; // contador de uso de sentencias almacenadas
    protected String cachedRowSetClassName = "com.sun.rowset.CachedRowSetImpl"; // se asigna otra implementacion...
    /**
     * Si EJBContext no es nulo indica que este es el EJB Container que maneja
     * la transacción y en lugar de connection.rollback() se hará
     * EJBContexts.setRollbackOnly y no connection.setAutoCommit (false),
     * ni tampoco connection.commit().
     */
    protected Object EJBContext = null;
    public Utilitats() {
        if (Boolean.getBoolean("debug-lwpf") || Boolean.getBoolean("debug-" + getClass().getName())){
            debug = true;
        }
    }
    /** Leer la propiedad de context.
     * @return Value of property context.
     *
     */
    public javax.naming.Context getContext(){
        if (context == null){
            try{
                context = new InitialContext();
                if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this +"::getContext()::context: " +
                        context + " \n");
            }catch (NamingException ne){
                throw new RuntimeException(ne);
            }
        }
        return context;
    }
    /** Asignar nueva propiedad a context.
     * @param context New valor of property context.
     *
     */
    public void setContext(javax.naming.Context context) {
        this.context = context;
    }
    /** Leer la propiedad de connection.
     * @return Value of property connection.
     *
     */
    public java.sql.Connection getConnection() throws SQLException{
        if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this +"::getConnection()::connection                  1: " + connection + "::isTransaccionEnCurso(): " + transaccionEnCurso + " \n");
        if (isTransaccionEnCurso()){
            return this.connection;
        }
        if (connection == null || connection.isClosed()){
            dataSource = this.getDataSource();
            if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this                    +"::getConnection()::dataSource 1: " + dataSource + " \n");
            connection = dataSource.getConnection();
            if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this +"::getConnection()::connection                    2: " + connection + " \n");
        }
        if (isTransaccionEnCurso()){
            if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this
                    +"::getConnection()::isTransaccionEnCurso(): " + isTransaccionEnCurso() + "::conexionId: " + conexionId + "\n");
            if (!this.conexionId.equals(connection.toString())){
                throw new SQLException("Se cerro la conexion mientras se ejecutaba una transaccion");
            }
        }
        if (isAdvertenciasProcesadas()){
            rellenarAdvertencias(connection.getWarnings());
            connection.clearWarnings();
        }
        return connection;
    }
    /** Asignar nueva propiedad a connection.
     * @param connection New valor of property connection.
     *
     */
    public void setConnection(java.sql.Connection connection) {
        this.connection = connection;
    }
    /** Leer la propiedad de dataSource.
     * @return Value of property dataSource.
     *
     */
    public javax.sql.DataSource getDataSource() throws SQLException{
        try{
            if (dataSource == null || isResetOrigenDatos()){
                if (nombreOrigenDatos == null){
                    throw new SQLException("Nombre de DataSource no existe");
                }else if (nombreOrigenDatos.indexOf("/") == -1){
                    dataSource = (DataSource) this.getContext().lookup("java:comp/env/jdbc/" + nombreOrigenDatos);
                }else{
                    dataSource = (DataSource) this.getContext().lookup(nombreOrigenDatos);
                }
            }
        }catch (NamingException ne){
            throw new RuntimeException(ne.getMessage());
        }
        if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this +"::getDataSource()::dataSource:                " + dataSource + " \n");
        return dataSource;
    }
    /** Asignar nueva propiedad a dataSource.
     * @param dataSource New valor of property dataSource.
     *
     */
    public void setDataSource(javax.sql.DataSource dataSource) {
        this.dataSource = dataSource;
    }
    protected void prepararStatement(String sql) throws SQLException{
        this.preparedStatement = this.getConnection().prepareStatement(sql, getResultadoSetType(), getConcurrencia());
        if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this +"::prepararStatement()::sql: \n"
                + sql + " \n");
        this.preparedStatement.setEscapeProcessing(this.getEscapeProcessing());
        this.preparedStatement.setFetchSize(this.getFetchLongitud());
        this.preparedStatement.setMaxRows(this.getMaxFilas());
        this.preparedStatement.setMaxFieldSize(this.getMaxLongitudCampo());
        this.preparedStatement.setQueryTimeout(this.getQueryTiempoLimite());
        if (this.getNombreCursor() != null){
            this.preparedStatement.setCursorName(this.getNombreCursor());
        }
    }
    /** Leer la propiedad de prepararStatement.
     * @return Value of property prepararStatement.
     *
     */
    public PreparedStatement getPreparedStatement(String sql, Collection colParms) throws SQLException{
        if (sql == null || sql.trim().length() == 0) {
            throw new SQLException("SQL String esta en blanco o es null");
        }
        if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this +"::===============                getPreparedStatement(): \n" + sql + " ::colParms: " + colParms + " \n");
        int idx = -1;
        if (almacenStatements){ // PreparedStatement será usado nuevamente, si no debe cerrarse y asignarle = null
            idx = sentenciasId.indexOf(sql);
            if (idx >= 0){
                Object objeto = sentenciasAlmacenamiento.get(idx);
                if (debug) {
                    System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this +"::===============                            getPreparedStatement() ============ hay almacenadas preparedStatement: \n" + "idx: " + idx + " " + sql + "::" + (objeto ==
                    null?"<null>":objeto.toString() + objeto.getClass()) + " \n");
                    System.out.println("lwpf ============ sentenciasId: " + sentenciasId);
                    System.out.println("lwpf ============ sentenciasAlmacenamiento: " + sentenciasAlmacenamiento);
                    System.out.println("lwpf ============ contadorSentenciasAlmacenadas: " + contadorSentenciasAlmacenadas);
                }
                preparedStatement = (PreparedStatement) sentenciasAlmacenamiento.get(idx);
                if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this +"::===============                        getPreparedStatement() ============ hay almacenadas preparedStatement: \n" + sql + "::" + preparedStatement + " \n");
                if (preparedStatement == null){
                    sentenciasId.remove(idx);
                    sentenciasAlmacenamiento.remove(idx);
                    idx = -1;
                }else{
                    preparedStatement.clearParameters();
                }
            }
        }
        if (idx == -1){
            prepararStatement(sql);
        }
        Iterator paramsIter = colParms.iterator();
        int parmIdx = 1;
        while(paramsIter.hasNext()){
            Object param = paramsIter.next();
            if (param != null){
                if (param.getClass().getName().equals("Date")){
                    param = new java.sql.Date(((java.util.Date) param).getTime());
                }
                preparedStatement.setObject(parmIdx, param);
            }else{
                preparedStatement.setNull(parmIdx, Types.JAVA_OBJECT);
            }
            parmIdx++;
        }
        if (almacenStatements){
            if (idx == -1){
                idx = addAlmacenStatement(sql, preparedStatement);
                contadorSentenciasAlmacenadas.add(new Integer(1));
            }else{
// ¿Cuantas veces se ha llamado a prepararStatement?
                Object contador = contadorSentenciasAlmacenadas.get(idx);
                if (contador == null){
                    contadorSentenciasAlmacenadas.add(new Integer(1));
                }else{
                    contadorSentenciasAlmacenadas.set(idx, new Integer(((Integer) contador).intValue() + 1));
                }
            }
        }
        if (isAdvertenciasProcesadas()){
            rellenarAdvertencias(preparedStatement.getWarnings());
            preparedStatement.clearWarnings();
        }
        return preparedStatement;
    }
    /** Asignar nueva propiedad a prepararStatement.
     * @param preparedStatement New valor of property prepararStatement.
     *
     */
    public void setPreparedStatement(java.sql.PreparedStatement preparedStatement) {
        this.preparedStatement = preparedStatement;
    }
    /**************************************************************************/
    public MagatzemDades[] getResultadoComoArrayMagatzemDades(String sql, Collection colParms, boolean llenarNombresColumna) throws
            SQLException{
        return (MagatzemDades[]) getResultadoComoListaMagatzemDades(sql, colParms, llenarNombresColumna).toArray(new
                MagatzemDades[0]);
    }
    public MagatzemDades[] getResultadoComoArrayMagatzemDades(String sql, boolean llenarNombresColumna) throws SQLException{
        return (MagatzemDades[]) getResultadoComoListaMagatzemDades(sql, llenarNombresColumna).toArray(new MagatzemDades[0]);
    }
    public MagatzemDades[] getResultadoComoArrayMagatzemDades(String sql) throws SQLException{
        return (MagatzemDades[]) getResultadoComoListaMagatzemDades(sql).toArray(new MagatzemDades[0]);
    }
    public MagatzemDades[] getResultadoComoArrayMagatzemDades(String sql, Collection colParms) throws SQLException{
        return (MagatzemDades[]) getResultadoComoListaMagatzemDades(sql, colParms).toArray(new MagatzemDades[0]);
    }
    public MagatzemDades[] getResultadosComoArrayMagatzemDades(String sql, Collection colParms) throws SQLException{
        return (MagatzemDades[]) getResultadosComoListaMagatzemDades(sql, colParms, true).toArray(new MagatzemDades[0]);
    }
    public MagatzemDades[] getResultadosComoArrayMagatzemDades(String sql, Collection colParms, boolean llenarNombresColumna) throws
            SQLException{
        return (MagatzemDades[]) getResultadosComoListaMagatzemDades(sql, colParms, llenarNombresColumna).toArray(new
                MagatzemDades[0]);
    }
    public MagatzemDades[] getResultadosComoArrayMagatzemDades(String sql, Collection colParms, int maxNumeroParametros, String
            marcadorPosicion) throws SQLException{
        return (MagatzemDades[]) getResultadosComoListaMagatzemDades(sql, colParms, maxNumeroParametros, marcadorPosicion,
                true).toArray(new MagatzemDades[0]);
    }
    public MagatzemDades[] getResultadosComoArrayMagatzemDades(String sql, Collection colParms, int maxNumeroParametros, String
            marcadorPosicion, boolean llenarNombresColumna) throws SQLException{
        return (MagatzemDades[]) getResultadosComoListaMagatzemDades(sql, colParms, maxNumeroParametros, marcadorPosicion,
                llenarNombresColumna).toArray(new MagatzemDades[0]);
    }
    /**************************************************************************/
    public Object getValorUnico(String sql) throws SQLException{
        Object valor = null;
        getResultSet(sql);
        if(this.resultSet.next()){
            valor = this.resultSet.getObject(1);
        }else{
            throw new SQLException("No data");
        }
        if (isAdvertenciasProcesadas()){
            rellenarAdvertencias(this.resultSet.getWarnings());
            this.resultSet.clearWarnings();
        }
        return valor;
    }
    public Object getValorUnico(String sql, Collection colParms) throws SQLException{
        Object valor = null;
        getResultSet(sql, colParms);
        if(this.resultSet.next()){
            valor = this.resultSet.getObject(1);
        }else{
            throw new SQLException("No data");
        }
        if (isAdvertenciasProcesadas()){
            rellenarAdvertencias(this.resultSet.getWarnings());
            this.resultSet.clearWarnings();
        }
        return valor;
    }
    /**************************************************************************/
    public List getResultadoUnicaColumnaComoLista(String sql) throws SQLException{
        getResultSet(sql);
        List lista = new ArrayList();
        while(this.resultSet.next()){
            lista.add(this.resultSet.getObject(1));
        }
        if (isAdvertenciasProcesadas()){
            rellenarAdvertencias(this.resultSet.getWarnings());
            this.resultSet.clearWarnings();
        }
        return lista;
    }
    public List getResultadoUnicaColumnaComoLista(String sql, Collection colParms) throws SQLException{
        getResultSet(sql, colParms);
        List lista = new ArrayList();
        while(this.resultSet.next()){
            lista.add(this.resultSet.getObject(1));
        }
        if (isAdvertenciasProcesadas()){
            rellenarAdvertencias(this.resultSet.getWarnings());
            this.resultSet.clearWarnings();
        }
        return lista;
    }
    public List getResultadosUnicaColumnaComoLista(String sql, Collection colParms, int maxNumeroParametros, String marcadorPosicion) throws
            SQLException{
        getResultSets(sql, colParms, maxNumeroParametros, marcadorPosicion);
        List lista = new ArrayList();
        for (int i = 0;i < resultSets.size();i++){
            while (((ResultSet) resultSets.get(i)).next() ){
                lista.add(((ResultSet) resultSets.get(i)).getObject(1));
            }
            if (isAdvertenciasProcesadas()){
                rellenarAdvertencias(((ResultSet) resultSets.get(i)).getWarnings());
                ((ResultSet) resultSets.get(i)).clearWarnings();
            }
        }
        return lista;
    }
    public List getResultadosUnicaColumnaComoLista(String sql, List listParms) throws SQLException{
        getResultSets(sql, listParms);
        List lista = new ArrayList();
        for (int i = 0;i < resultSets.size();i++){
            while (((ResultSet) resultSets.get(i)).next() ){
                lista.add(((ResultSet) resultSets.get(i)).getObject(1));
            }
            if (isAdvertenciasProcesadas()){
                rellenarAdvertencias(((ResultSet) resultSets.get(i)).getWarnings());
                ((ResultSet) resultSets.get(i)).clearWarnings();
            }
        }
        return lista;
    }
    /**************************************************************************/
    public Map getResultadoDosColumnasComoMap(String sql) throws SQLException{
        getResultSet(sql);
        Map colMap = new LinkedHashMap();
        while(this.resultSet.next()){
            colMap.put(this.resultSet.getObject(1), this.resultSet.getObject(2));
        }
        if (isAdvertenciasProcesadas()){
            rellenarAdvertencias(this.resultSet.getWarnings());
            this.resultSet.clearWarnings();
        }
        return colMap;
    }
    public Map getResultadoDosColumnasComoMap(String sql, Collection colParms) throws SQLException{
        getResultSet(sql, colParms);
        Map colMap = new LinkedHashMap();
        while(this.resultSet.next()){
            colMap.put(this.resultSet.getObject(1), this.resultSet.getObject(2));
        }
        return colMap;
    }
    public Map getResultadosDosColumnasComoMap(String sql, Collection colParms, int numeroMaximoParametros, String marcadorPosicion)
            throws SQLException{
        getResultSets(sql, colParms, numeroMaximoParametros, marcadorPosicion);
        Map colMap = new LinkedHashMap();
        for (int i = 0;i < resultSets.size();i++){
            while (((ResultSet) resultSets.get(i)).next() ){
                colMap.put(this.resultSet.getObject(1), this.resultSet.getObject(2));
            }
            if (isAdvertenciasProcesadas()){
                rellenarAdvertencias(((ResultSet) resultSets.get(i)).getWarnings());
                ((ResultSet) resultSets.get(i)).clearWarnings();
            }
        }
        return colMap;
    }
    public Map getResultadosDosColumnasComoMap(String sql, List listParams) throws SQLException{
        getResultSets(sql, listParams);
        Map colMap = new LinkedHashMap();
        for (int i = 0;i < resultSets.size();i++){
            while (((ResultSet) resultSets.get(i)).next() ){
                colMap.put(this.resultSet.getObject(1), this.resultSet.getObject(2));
            }
            if (isAdvertenciasProcesadas()){
                rellenarAdvertencias(((ResultSet) resultSets.get(i)).getWarnings());
                ((ResultSet) resultSets.get(i)).clearWarnings();
            }
        }
        return colMap;
    }
    /**************************************************************************/
    public List getResultadoComoValoresListaObjetos(String sql) throws SQLException{
        getResultSet(sql);
        List listObj = new ArrayList();
        while(this.resultSet.next()){
            listObj.add(new ContingutObjecte(this.resultSet.getObject(1), this.resultSet.getString(2)));
        }
        if (isAdvertenciasProcesadas()){
            rellenarAdvertencias(this.resultSet.getWarnings());
            this.resultSet.clearWarnings();
        }
        return listObj;
    }
    public List getResultadoComoValoresListaObjetos(String sql, Collection colParms) throws SQLException{
        getResultSet(sql, colParms);
        List listObj = new ArrayList();
        while(this.resultSet.next()){
            listObj.add(new ContingutObjecte(this.resultSet.getObject(1), this.resultSet.getString(2)));
        }
        return listObj;
    }
    public List getResultadoComoValoresListaObjetos(String sql, Collection colParms, int numeroMaximoParametros, String marcadorPosicion)
            throws SQLException{
        getResultSets(sql, colParms, numeroMaximoParametros, marcadorPosicion);
        List listObj = new ArrayList();
        for (int i = 0;i < resultSets.size();i++){
            while (((ResultSet) resultSets.get(i)).next() ){
                listObj.add(new ContingutObjecte(this.resultSet.getObject(1), this.resultSet.getString(2)));
            }
            if (isAdvertenciasProcesadas()){
                rellenarAdvertencias(((ResultSet) resultSets.get(i)).getWarnings());
                ((ResultSet) resultSets.get(i)).clearWarnings();
            }
        }
        return listObj;
    }
    public List getResultadosComoValoresListaObjetos(String sql, List params) throws SQLException{
        getResultSets(sql, params);
        List listObj = new ArrayList();
        for (int i = 0;i < resultSets.size();i++){
            while (((ResultSet) resultSets.get(i)).next() ){
                listObj.add(new ContingutObjecte(this.resultSet.getObject(1), this.resultSet.getString(2)));
            }
            if (isAdvertenciasProcesadas()){
                rellenarAdvertencias(((ResultSet) resultSets.get(i)).getWarnings());
                ((ResultSet) resultSets.get(i)).clearWarnings();
            }
        }
        return listObj;
    }
    /**************************************************************************/
    public List getResultadoComoListaMagatzemDades(String sql, Collection colParms, boolean rellenarNombresColumnas) throws SQLException{
        getResultSet(sql, colParms);
        ResultSetMetaData rsmd = this.resultSet.getMetaData();
        int contColum = rsmd.getColumnCount();
        List listDatos = new ArrayList();
        String[] nombresColum = new String[contColum];
        Map dups = new HashMap();
        if (rellenarNombresColumnas){
// rename mapDatos if there are duplicate names
            for (int col = 1;col <= contColum;col++){
                String nombreColum = rsmd.getColumnName(col);
                if (!dups.containsKey(nombreColum)){
                    dups.put(nombreColum, new Integer(0));
                }else{
                    Integer num = (Integer) dups.get(nombreColum);
                    int intValor = num.intValue();
                    num = new Integer(intValor + 1);
                    dups.put(nombreColum, num);
                    nombreColum = nombreColum + num;
                }
                nombresColum[col - 1] = nombreColum;
            }
        }
        while(this.resultSet.next()){
            MagatzemDades cd = new MagatzemDades(contColum);
            for (int col = 1;col <= contColum;col++){
                if (rellenarNombresColumnas){
                    cd.setNomCampAmbValor(col, nombresColum[col - 1], this.resultSet.getObject(col));
                }else{
                    cd.setObjecte(col, this.resultSet.getObject(col));
                }
            }
            listDatos.add(cd);
        }
        if (isAdvertenciasProcesadas()){
            rellenarAdvertencias(this.resultSet.getWarnings());
            this.resultSet.clearWarnings();
        }
        return listDatos;
    }
    public List getResultadoComoListaMagatzemDades(String sql, boolean rellenarNombresColumnas) throws SQLException{
        getResultSet(sql);
        ResultSetMetaData rsmd = this.resultSet.getMetaData();
        int contColum = rsmd.getColumnCount();
        List listDatos = new ArrayList();
        String[] nombresColum = new String[contColum];
        Map dups = new HashMap();
        if (rellenarNombresColumnas){
// rename mapDatos if there are duplicate names
            for (int col = 1;col <= contColum;col++){
                String nombreColum = rsmd.getColumnName(col);
                if (!dups.containsKey(nombreColum)){
                    dups.put(nombreColum, new Integer(0));
                }else{
                    Integer num = (Integer) dups.get(nombreColum);
                    int intValor = num.intValue();
                    num = new Integer(intValor + 1);
                    dups.put(nombreColum, num);
                    nombreColum = nombreColum + num;
                }
                nombresColum[col - 1] = nombreColum;
            }
        }
        while(this.resultSet.next()){
            MagatzemDades cd = new MagatzemDades(contColum);
            for (int col = 1;col <= contColum;col++){
                if (rellenarNombresColumnas){
                    cd.setNomCampAmbValor(col, nombresColum[col - 1], this.resultSet.getObject(col));
                }else{
                    cd.setObjecte(col, this.resultSet.getObject(col));
                }
            }
            listDatos.add(cd);
        }
        if (isAdvertenciasProcesadas()){
            rellenarAdvertencias(this.resultSet.getWarnings());
            this.resultSet.clearWarnings();
        }
        return listDatos;
    }
    public List getResultadoComoListaMagatzemDades(String sql) throws SQLException{
        return getResultadoComoListaMagatzemDades(sql, true);
    }
    public List getResultadoComoListaMagatzemDades(String sql, Collection colParms) throws SQLException{
        return getResultadoComoListaMagatzemDades(sql, colParms, true);
    }
    public List getResultadosComoListaMagatzemDades(String sql, Collection colParms) throws SQLException{
        return getResultadosComoListaMagatzemDades(sql, colParms, true);
    }
    public List getResultadosComoListaMagatzemDades(String sql, Collection params, int numeroMaximoParametros, String marcadorPosicion)
            throws SQLException{
        return getResultadosComoListaMagatzemDades(sql, params, numeroMaximoParametros, marcadorPosicion, true);
    }
    public List getResultadosComoListaMagatzemDades(String sql, Collection colParms, int numeroMaximoParametros, String marcadorPosicion,
                                                      boolean rellenarNombresColumnas) throws SQLException{
        getResultSets(sql, colParms, numeroMaximoParametros, marcadorPosicion);
        ResultSetMetaData rsmd = ((ResultSet) this.resultSets.get(0)).getMetaData();
        int contColum = rsmd.getColumnCount();
        List listDatos = new ArrayList();
        String[] nombresColum = new String[contColum];
        Map dups = new HashMap();
// cambiar el nombre a mapDatos si hay nombres duplicados
        for (int col = 1;col <= contColum;col++){
            String nombreColum = rsmd.getColumnName(col);
            if (!dups.containsKey(nombreColum)){
                dups.put(nombreColum, new Integer(0));
            }else{
                Integer num = (Integer) dups.get(nombreColum);
                int intValor = num.intValue();
                num = new Integer(intValor + 1);
                dups.put(nombreColum, num);
                nombreColum = nombreColum + num;
            }
            nombresColum[col - 1] = nombreColum;
        }
        for (int i = 0;i < resultSets.size();i++){
            while (((ResultSet) resultSets.get(i)).next() ){
                MagatzemDades cd = new MagatzemDades(contColum);
                for (int col = 1;col <= contColum;col++){
                    if (rellenarNombresColumnas){
                        Object value = ((ResultSet) resultSets.get(i)).getObject(col);
                        cd.setNomCampAmbValor(col, nombresColum[col - 1], ((ResultSet) resultSets.get(i)).getObject(col));
                    }else{
                        cd.setObjecte(col, ((ResultSet) resultSets.get(i)).getObject(col));
                    }
                }
                listDatos.add(cd);
            }
            if (isAdvertenciasProcesadas()){
                rellenarAdvertencias(((ResultSet) resultSets.get(i)).getWarnings());
                ((ResultSet) resultSets.get(i)).clearWarnings();
            }
        }
        return listDatos;
    }
    public List getResultadosComoListaMagatzemDades(String sql, Collection colParms, boolean rellenarNombresColumnas) throws SQLException{
        getResultSets(sql, colParms, numeroMaximoParametros, marcadorPosicion);
        ResultSetMetaData rsmd = ((ResultSet) this.resultSets.get(0)).getMetaData();
        int contColum = rsmd.getColumnCount();
        List listDatos = new ArrayList();
        String[] nombresColum = new String[contColum];
        Map dups = new HashMap();
// cambiar el nombre a mapDatos si hay nombres duplicados
        for (int col = 1;col <= contColum;col++){
            String nombreColum = rsmd.getColumnName(col);
            if (!dups.containsKey(nombreColum)){
                dups.put(nombreColum, new Integer(0));
            }else{
                Integer num = (Integer) dups.get(nombreColum);
                int intValor = num.intValue();
                num = new Integer(intValor + 1);
                dups.put(nombreColum, num);
                nombreColum = nombreColum + num;
            }
            nombresColum[col - 1] = nombreColum;
        }
        for (int i = 0;i < resultSets.size();i++){
            while (((ResultSet) resultSets.get(i)).next() ){
                MagatzemDades cd = new MagatzemDades(contColum);
                for (int col = 1;col <= contColum;col++){
                    if (rellenarNombresColumnas){
                        Object value = ((ResultSet) resultSets.get(i)).getObject(col);
                        cd.setNomCampAmbValor(col, nombresColum[col - 1], ((ResultSet) resultSets.get(i)).getObject(col));
                    }else{
                        cd.setObjecte(col, ((ResultSet) resultSets.get(i)).getObject(col));
                    }
                }
                listDatos.add(cd);
            }
            if (isAdvertenciasProcesadas()){
                rellenarAdvertencias(((ResultSet) resultSets.get(i)).getWarnings());
                ((ResultSet) resultSets.get(i)).clearWarnings();
            }
        }
        return listDatos;
    }
/**************************************************************************/
    /** @return Vector de Vectores */
    public Vector getResultadosComoVector(String sql, Collection colParms, int numeroMaximoParametros, String marcadorPosicion) throws
            SQLException{
        getResultSets(sql, colParms, numeroMaximoParametros, marcadorPosicion);
        int contColum = ((ResultSet) this.resultSets.get(0)).getMetaData().getColumnCount();
        Vector vectorDatos = new Vector();
        for (int i = 0;i < resultSets.size();i++){
            while (((ResultSet) resultSets.get(i)).next() ){
                Vector v = new Vector(contColum);
                for (int col = 1;col <= contColum;col++){
                    Object valor = ((ResultSet) resultSets.get(i)).getObject(col);
                    v.add(valor);
                }
                vectorDatos.add(v);
            }
            if (isAdvertenciasProcesadas()){
                rellenarAdvertencias(((ResultSet) resultSets.get(i)).getWarnings());
                ((ResultSet) resultSets.get(i)).clearWarnings();
            }
        }
        return vectorDatos;
    }
    /** @return Vector de Vectores */
    public Vector getResultadosComoVector(String sql, Collection colParms) throws SQLException{
        getResultSets(sql, colParms);
        int contColum = ((ResultSet) this.resultSets.get(0)).getMetaData().getColumnCount();
        Vector vectorDatos = new Vector();
        for (int i = 0;i < resultSets.size();i++){
            while (((ResultSet) resultSets.get(i)).next() ){
                Vector v = new Vector(contColum);
                for (int col = 1;col <= contColum;col++){
                    Object valor = ((ResultSet) resultSets.get(i)).getObject(col);
                    v.add(valor);
                }
                vectorDatos.add(v);
            }
            if (isAdvertenciasProcesadas()){
                rellenarAdvertencias(((ResultSet) resultSets.get(i)).getWarnings());
                ((ResultSet) resultSets.get(i)).clearWarnings();
            }
        }
        return vectorDatos;
    }
    public Vector getResultadoComoVector(String sql) throws SQLException{
        getResultSet(sql);
        int colCount = this.resultSet.getMetaData().getColumnCount();
        Vector vectorDatos = new Vector();
        while(this.resultSet.next()){
            Vector v = new Vector(colCount);
            for (int col = 1;col <= colCount;col++){
                v.add(this.resultSet.getObject(col));
            }
            vectorDatos.add(v);
        }
        if (isAdvertenciasProcesadas()){
            rellenarAdvertencias(this.resultSet.getWarnings());
            this.resultSet.clearWarnings();
        }
        return vectorDatos;
    }
    /** @return Vector de Vectores */
    public Vector getResultadoComoVector(String sql, Collection colParms) throws SQLException{
        getResultSet(sql, colParms);
        int colCount = this.resultSet.getMetaData().getColumnCount();
        Vector vectorDatos = new Vector();
        while(this.resultSet.next()){
            Vector v = new Vector(colCount);
            for (int col = 1;col <= colCount;col++){
                v.add(this.resultSet.getObject(col));
            }
            vectorDatos.add(v);
        }
        if (isAdvertenciasProcesadas()){
            rellenarAdvertencias(this.resultSet.getWarnings());
            this.resultSet.clearWarnings();
        }
        return vectorDatos;
    }
/**************************************************************************/
    /** @return Map of Lists. Cada clave es un nombre de listDatos y cada valor es un List de valores de listDatos */
    public Map getResultadosComoMap(String sql, Collection colParms) throws SQLException{
        getResultSets(sql, colParms);
        ResultSetMetaData rsmd = ((ResultSet) this.resultSets.get(0)).getMetaData();
        int colCount = rsmd.getColumnCount();
        Map mapDatos = new LinkedHashMap(colCount);
        List[] listDatos = new ArrayList[colCount];
        for (int i = 0;i < listDatos.length;i++){
            listDatos[i] = new ArrayList();
        }
        for (int i = 0;i < resultSets.size();i++){
            while (((ResultSet) resultSets.get(i)).next() ){
                for (int col = 1;col <= colCount;col++){
                    Object valor = ((ResultSet) resultSets.get(i)).getObject(col);
                    listDatos[col - 1].add(valor);
                }
            }
            if (isAdvertenciasProcesadas()){
                rellenarAdvertencias(((ResultSet) resultSets.get(i)).getWarnings());
                ((ResultSet) resultSets.get(i)).clearWarnings();
            }
        }
        Map dups = new HashMap();
        for (int col = 1;col <= colCount;col++){
            String nombreColum = rsmd.getColumnName(col);
            if (!dups.containsKey(nombreColum)){
                dups.put(nombreColum, new Integer(0));
            }else{
                Integer i = (Integer) dups.get(nombreColum);
                int intValor = i.intValue();
                i = new Integer(intValor + 1);
                dups.put(nombreColum, i);
                nombreColum = nombreColum + i;
            }
            mapDatos.put(nombreColum, listDatos[col - 1]);
        }
        return mapDatos;
    }
    /** @return Map of Lists. Cada clave es un nombre de listDatos y cada valor es una List de valores de listDatos */
    public Map getResultadosComoMap(String sql, Collection colParms, int numeroMaximoParametros, String marcadorPosicion) throws
            SQLException{
        getResultSets(sql, colParms, numeroMaximoParametros, marcadorPosicion);
        ResultSetMetaData rsmd = ((ResultSet) this.resultSets.get(0)).getMetaData();
        int colCount = rsmd.getColumnCount();
        Map mapDatos = new LinkedHashMap(colCount);
        List[] listDatos = new ArrayList[colCount];
        for (int i = 0;i < listDatos.length;i++){
            listDatos[i] = new ArrayList();
        }
        for (int i = 0;i < resultSets.size();i++){
            while (((ResultSet) resultSets.get(i)).next() ){
                for (int col = 1;col <= colCount;col++){
                    Object valor = ((ResultSet) resultSets.get(i)).getObject(col);
                    listDatos[col - 1].add(valor);
                }
            }
            if (isAdvertenciasProcesadas()){
                rellenarAdvertencias(((ResultSet) resultSets.get(i)).getWarnings());
                ((ResultSet) resultSets.get(i)).clearWarnings();
            }
        }
        Map dups = new HashMap();
        for (int col = 1;col <= colCount;col++){
            String nombreColum = rsmd.getColumnName(col);
            if (!dups.containsKey(nombreColum)){
                dups.put(nombreColum, new Integer(0));
            }else{
                Integer i = (Integer) dups.get(nombreColum);
                int intValor = i.intValue();
                i = new Integer(intValor + 1);
                dups.put(nombreColum, i);
                nombreColum = nombreColum + i;
            }
            mapDatos.put(nombreColum, listDatos[col - 1]);
        }
        return mapDatos;
    }
    /** @return Map of Lists. Cada clave es un nombre de listDatos y cada valor es una List de valores de listDatos */
    public Map getResultadoComoMap(String sql, Collection colParms) throws SQLException{
        getResultSet(sql, colParms);
        ResultSetMetaData rsmd = this.resultSet.getMetaData();
        int colCount = rsmd.getColumnCount();
        Map mapDatos = new LinkedHashMap(colCount);
        List[] listDatos = new ArrayList[colCount];
        for (int i = 0;i < listDatos.length;i++){
            listDatos[i] = new ArrayList();
        }
        while(this.resultSet.next()){
            for (int col = 1;col <= colCount;col++){
                Object valor = this.resultSet.getObject(col);
                listDatos[col - 1].add(valor);
            }
        }
        Map dups = new HashMap();
        for (int col = 1;col <= colCount;col++){
            String nombreColum = rsmd.getColumnName(col);
            if (!dups.containsKey(nombreColum)){
                dups.put(nombreColum, new Integer(0));
            }else{
                Integer i = (Integer) dups.get(nombreColum);
                int intValor = i.intValue();
                i = new Integer(intValor + 1);
                dups.put(nombreColum, i);
                nombreColum = nombreColum + i;
            }
            mapDatos.put(nombreColum, listDatos[col - 1]);
        }
        if (isAdvertenciasProcesadas()){
            rellenarAdvertencias(this.resultSet.getWarnings());
            this.resultSet.clearWarnings();
        }
        return mapDatos;
    }
    /** @return Map of Lists. Cada clave es un nombre de listDatos y cada valor es una List de valores de listDatos */
    public Map getResultadoComoMap(String sql) throws SQLException{
        getResultSet(sql);
        ResultSetMetaData rsmd = this.resultSet.getMetaData();
        int colCount = rsmd.getColumnCount();
        Map mapDatos = new LinkedHashMap(colCount);
        List[] listDatos = new ArrayList[colCount];
        for (int i = 0;i < listDatos.length;i++){
            listDatos[i] = new ArrayList();
        }
        while(this.resultSet.next()){
            for (int col = 1;col <= colCount;col++){
                Object valor = this.resultSet.getObject(col);
                listDatos[col - 1].add(valor);
            }
        }
        Map dups = new HashMap();
        for (int col = 1;col <= colCount;col++){
            String nombreColum = rsmd.getColumnName(col);
            if (!dups.containsKey(nombreColum)){
                dups.put(nombreColum, new Integer(0));
            }else{
                Integer i = (Integer) dups.get(nombreColum);
                int intValor = i.intValue();
                i = new Integer(intValor + 1);
                dups.put(nombreColum, i);
                nombreColum = nombreColum + i;
            }
            mapDatos.put(nombreColum, listDatos[col - 1]);
        }
        if (isAdvertenciasProcesadas()){
            rellenarAdvertencias(this.resultSet.getWarnings());
            this.resultSet.clearWarnings();
        }
        return mapDatos;
    }
/**************************************************************************/
    /** Leer la propiedad de resultSet.
     * @return Value of property resultSet.
     *
     */
    public java.sql.ResultSet getResultSet(String sql) throws SQLException{
        if (resultSet != null && isCerrarResultSet()){
            if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this +"::getResultSet()::closing                    ResultSet: " + resultSet + " \n");
            resultSet.close();
        }
        resultSet = this.getStatement(sql).executeQuery(sql);
        if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this +"::getResultSet()::sql: \n" + sql +
                " \n");
        if (isAdvertenciasProcesadas()){
            rellenarAdvertencias(resultSet.getWarnings());
            this.resultSet.clearWarnings();
        }
        return resultSet;
    }
    public java.sql.ResultSet getResultSet(String sql, Collection colParms) throws SQLException{
        if (resultSet != null && isCerrarResultSet()){
            resultSet.close();
            if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this +"::getResultSet()::cerrando                    ResultSet: " + resultSet + " \n");
        }
        resultSet = this.getPreparedStatement(sql, colParms).executeQuery();
        if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this +"::getResultSet(): " + resultSet + "                \n");
        if (isAdvertenciasProcesadas()){
            rellenarAdvertencias(resultSet.getWarnings());
        }
        return resultSet;
    }
    public java.sql.ResultSet[] getResultSets(String sql, Collection colParms, int numeroMaximoParametros, String marcadorPosicion) throws
            SQLException{
        this.numeroMaximoParametros = numeroMaximoParametros;
        this.marcadorPosicion = marcadorPosicion;
        return getResultSets(sql, colParms);
    }
    public java.sql.ResultSet[] getResultSets(String sql, Collection colParms) throws SQLException{
/**
 * Este es el método más conveniente para construir sentencias con la cláusula SQL 'IN'
 * si la cantidad de argumentos que se usarán en la sentencia con la cláusula "IN" es
 * más grande que el número de máximo de parámetros que la base de datos puede tratar.
 * Generará varios objetos ResultSet.
 * La lista de argumentos que es más grande que el número de máximo de los parámetros
 * que la base de datos puede tratar debe estar en el último lugar en la variable colParms.
 * También, tanto marcadorPosicion como numeroMaximoParametros deben ser el asignados.
 *
 * Ejemplo de uso:
 * String sql = "SELECT * FROM CUSTOMER WHERE LAST_NAME <> ? AND CUSTOMER_ID IN (:#)";
 * Collection argsList = new ArrayList();
 * List custId = new ArrayList();
 * custId.add(new Integer(0));
 * custId.add(new Integer(1));
 * custId.add(new Integer(2));
 * custId.add(new Integer(3));
 * custId.add(new Integer(4));
 * custId.add(new Integer(5));
 * custId.add(new Integer(6));
 * custId.add(new Integer(7));
 * argsList.add("Ricardo García");
 * argsList.add(custId);
 * factory.getDBServices().setNumeroMaximoParametros(3);
 * factory.getDBServices().setMarcadorPosicion(":#");
 * factory.load(factory.getDBServices().getResultSets(sql, argsList));
 * factory.getDBServices().release(true);
 */
        closeResults();
        resultSets = new ArrayList();
        Collection nuevaListaArgs = new ArrayList();
        String nuevaSQL = null;
        Collection nuevaListaArgs1 = null;
        boolean cargado = false;
        boolean cerrarResultOriginal = this.cerrarResultSet;
        this.cerrarResultSet = false;
        int parametrosCompuestos = 0;
        int longitudParams = colParms.size();
        Iterator testParamsIter = colParms.iterator();
        while (testParamsIter.hasNext()){
            Object obj = testParamsIter.next();
            if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this +"::getResultSets()::obj:" + obj +
                    "::instanceof Collection: " + (obj instanceof Collection) + " \n");
            if (obj instanceof Collection){ // es un parametro compuesto
                parametrosCompuestos++;
            }
        }
        String[] marcadoresPosicionTest = sql.split(this.marcadorPosicion);
        if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this +"::getResultSets()::sql: \n" + sql +
                "::marcadoresPosicionTest: " + Arrays.asList(marcadoresPosicionTest) + " \n");
        if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this +"::getResultSets()::sql: \n" + sql +
                "::parametrosCompuestos: " + parametrosCompuestos + "::marcadoresPosicionTest.length: " + marcadoresPosicionTest.length + " \n");
        if ((marcadoresPosicionTest.length - 1) != parametrosCompuestos){
            throw new SQLException("Number of placeholders in sql is not equal to number of compound parameters");
        }
        try{
            Iterator iter1 = colParms.iterator();
            int contParams = 0;
            while (iter1.hasNext()){
                Object argActual = iter1.next();
                if (argActual instanceof Collection){ // es un parametro compuesto
                    if (numeroMaximoParametros < 0){
                        throw new SQLException("Invalid maxNumberOfParams: " + numeroMaximoParametros);
                    }
                    List lista = new ArrayList((Collection) argActual);
                    int thisParmSize = lista.size();
                    if (thisParmSize > numeroMaximoParametros){
                        if (contParams < (longitudParams - 1)){
                            throw new SQLException("Only the last entry can have more arguments then Max Number of Parameters");
                        }
                        nuevaSQL = sql;
                        StringBuffer sb = new StringBuffer();
                        Iterator iter3 = lista.iterator();
                        int cont = 0;
                        int total = 0;
                        List temp = new ArrayList();
                        Object paramValor = null;
                        for (int i = 0;i < thisParmSize;i++){
                            if (cont < (numeroMaximoParametros)){
                                paramValor = lista.get(i);
                                sb.append("?,");
                                temp.add(paramValor);
                                if (i == (thisParmSize - 1)){
                                    int idx = sb.length() - 1;
                                    char c = sb.charAt(idx);
                                    if (c == ','){
                                        sb.deleteCharAt(idx);
                                    }
                                    nuevaSQL = sql.replaceFirst(marcadorPosicion, sb.toString());
                                    nuevaListaArgs1 = new ArrayList(nuevaListaArgs);
                                    nuevaListaArgs1.addAll(temp);
                                    if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this
                                            +"::getResultSets()::sql: " + nuevaSQL + "::args: " + nuevaListaArgs1 + " \n");
                                    resultSets.add(this.getPreparedStatement(nuevaSQL, nuevaListaArgs1).executeQuery());
                                    cargado = true;
                                    break;
                                }
                                cont++;
                            }else if (cont == (numeroMaximoParametros)){
                                int idx = sb.length() - 1;
                                char c = sb.charAt(idx);
                                if (c == ','){
                                    sb.deleteCharAt(idx);
                                }
                                nuevaSQL = sql.replaceFirst(marcadorPosicion, sb.toString());
                                nuevaListaArgs1 = new ArrayList(nuevaListaArgs);
                                nuevaListaArgs1.addAll(temp);
                                if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this
                                        +"::getResultSets()::sql: " + nuevaSQL + "::args: " + nuevaListaArgs1 + " \n");
                                resultSets.add(this.getPreparedStatement(nuevaSQL, nuevaListaArgs1).executeQuery());
                                cargado = true;
                                temp.clear();
                                sb.setLength(0);
                                nuevaSQL = sql;
                                cont = 0;
                                i--;
                            }
                        }
                    }else{
                        StringBuffer sb = new StringBuffer();
                        Iterator iter2 = lista.iterator();
                        while (iter2.hasNext()){
                            sb.append("?,");
                            nuevaListaArgs.add(iter2.next());
                        }
                        sb.deleteCharAt(sb.lastIndexOf(","));
                        sql = sql.replaceFirst(marcadorPosicion, sb.toString());
                    }
                }else{ // es un parametro corriente
                    nuevaListaArgs.add(argActual);
                }
                contParams++;
            }
            if (!cargado){
                if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this +"::getResultSets()::sql: \n" +
                        sql + "::args: " + nuevaListaArgs + " \n");
                resultSets.add(this.getPreparedStatement(sql, nuevaListaArgs).executeQuery());
            }
        }catch(Exception e){
            e.printStackTrace();
            throw new SQLException(e.getMessage());
        }
        setCerrarResultSet(cerrarResultOriginal);
        return (java.sql.ResultSet[]) resultSets.toArray(new ResultSet[0]);
    }
    public List ejecutarProcedimientoAlmacenado(String sql, DadesAuxiliars params, int proccessResult) throws SQLException{
        if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this
                +"::ejecutarProcedimientoAlmacenado()::sql: \n" + sql + "\n");
        List valorDevuelto = new ArrayList();
        try {
            callStatement = getConnection().prepareCall(sql);
            for (int i = 1;i <= params.getParameterCount();i++){
                int paramMode = params.getParameterMode(i);
                if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this
                        +"::ejecutarProcedimientoAlmacenado()::paramMode: " + paramMode + "::paramIndex: " + i + "::paramTipo: " + params.getParameterType(i) +
                        "::parameterName: " + params.getParameterName(i) + "::valorParms: " + params.getParameter(i) + "\n");
                if (paramMode == DadesAuxiliars.parameterModeIn){
                    callStatement.setObject(i, params.getParameter(i));
                }else if (paramMode == DadesAuxiliars.parameterModeOut){
                    callStatement.registerOutParameter(i, params.getParameterType(i));
                }else if (paramMode == DadesAuxiliars.parameterModeInOut){
                    callStatement.registerOutParameter(i, params.getParameterType(i));
                    callStatement.setObject(i, params.getParameter(i));
                }
            }
            ResultSet result = null;
            int filasAfectadas = 0;
            boolean hasResult = callStatement.execute();
            if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this
                    +"::ejecutarProcedimientoAlmacenado()::hasResult: " + hasResult + "\n");
// procesar ResultSet(s) con/sin updateCount
            while (hasResult || filasAfectadas != -1){
                if (hasResult == true){
                    result = callStatement.getResultSet();
                    try{
                        if (proccessResult == IGNORAR_RESULTADO){
// no hacer nada
                        }else if (proccessResult == RESULTADO_LISTA_CONTENEDOR_DATOS){
                            ResultSetMetaData rsmd = result.getMetaData();
                            int contColum = rsmd.getColumnCount();
                            List listDatos = new ArrayList();
                            String[] nombresColum = new String[contColum];
                            Map dups = new HashMap();
// cambiar el nombre de mapDatos si hay nombres duplicados
                            for (int col = 1;col <= contColum;col++){
                                String nombreColum = rsmd.getColumnName(col);
                                if (!dups.containsKey(nombreColum)){
                                    dups.put(nombreColum, new Integer(0));
                                }else{
                                    Integer num = (Integer) dups.get(nombreColum);
                                    int intValor = num.intValue();
                                    num = new Integer(intValor + 1);
                                    dups.put(nombreColum, num);
                                    nombreColum = nombreColum + num;
                                }
                                nombresColum[col - 1] = nombreColum;
                            }
                            while(result.next()){
                                MagatzemDades cd = new MagatzemDades(contColum);
                                for (int col = 1;col <= contColum;col++){
                                    cd.setNomCampAmbValor(col, nombresColum[col - 1], result.getObject(col));
                                }
                                listDatos.add(cd);
                            }
                            if (isAdvertenciasProcesadas()){
                                rellenarAdvertencias(result.getWarnings());
                                result.clearWarnings();
                            }
                            valorDevuelto.add(listDatos);
                        }else if (proccessResult == RESULTADO_VECTOR){
                            int contColum = result.getMetaData().getColumnCount();
                            Vector vectorDatos = new Vector();
                            while(result.next()){
                                Vector v = new Vector(contColum);
                                for (int col = 1;col <= contColum;col++){
                                    v.add(result.getObject(col));
                                }
                                vectorDatos.add(v);
                            }
                            if (isAdvertenciasProcesadas()){
                                rellenarAdvertencias(result.getWarnings());
                                result.clearWarnings();
                            }
                            valorDevuelto.add(vectorDatos);
                        }else if (proccessResult == RESULTADO_MAP){
                            ResultSetMetaData rsmd = result.getMetaData();
                            int contColum = rsmd.getColumnCount();
                            Map mapDatos = new LinkedHashMap(contColum);
                            List[] listDatos = new ArrayList[contColum];
                            for (int i = 0;i < listDatos.length;i++){
                                listDatos[i] = new ArrayList();
                            }
                            while(result.next()){
                                for (int col = 1;col <= contColum;col++){
                                    Object obj = result.getObject(col);
                                    listDatos[col - 1].add(obj);
                                }
                            }
                            Map dups = new HashMap();
                            for (int col = 1;col <= contColum;col++){
                                String nombreColum = rsmd.getColumnName(col);
                                if (!dups.containsKey(nombreColum)){
                                    dups.put(nombreColum, new Integer(0));
                                }else{
                                    Integer i = (Integer) dups.get(nombreColum);
                                    int intValor = i.intValue();
                                    i = new Integer(intValor + 1);
                                    dups.put(nombreColum, i);
                                    nombreColum = nombreColum + i;
                                }
                                mapDatos.put(nombreColum, listDatos[col - 1]);
                            }
                            if (isAdvertenciasProcesadas()){
                                rellenarAdvertencias(result.getWarnings());
                                result.clearWarnings();
                            }
                            valorDevuelto.add(mapDatos);
                        }else if (proccessResult == RESULTADO_ROWSET){
                            javax.sql.rowset.CachedRowSet crs = (javax.sql.rowset.CachedRowSet) Class.forName(cachedRowSetClassName).newInstance();
                            crs.populate(result);
                            valorDevuelto.add(crs);
                        }
                    }finally{
                        if (isAdvertenciasProcesadas()){
                            rellenarAdvertencias(result.getWarnings());
                            result.clearWarnings();
                        }
                        if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this
                                +"::ejecutarProcedimientoAlmacenado()::cerrando ResultSet: " + result + " \n");
                        result.close();
                        result = null;
                    }
                }else{
                    filasAfectadas = callStatement.getUpdateCount();
                    if (filasAfectadas != -1){
                        valorDevuelto.add(new Integer(filasAfectadas));
                    }
                }
                hasResult = callStatement.getMoreResults();
            }
// procesar parametros tipo: OUT y/o INOUT
            for (int i = 1;i <= params.getParameterCount();i++){
                int paramMode = params.getParameterMode(i);
                if (paramMode == DadesAuxiliars.parameterModeOut || paramMode == DadesAuxiliars.parameterModeInOut){
                    Object obj = callStatement.getObject(i);
                    params.setParameter(i, obj);
                }
            }
            if (isAdvertenciasProcesadas()){
                rellenarAdvertencias(callStatement.getWarnings());
                this.callStatement.clearWarnings();
            }
            valorDevuelto.add(params);
        } catch (Exception e){
            e.printStackTrace();
            throw new SQLException(e.getMessage());
        }finally{
            if (isCerrarStatementTrasEjecucion()){
                if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this
                        +"::ejecutarProcedimientoAlmacenado()::cerrando CallableStatement: " + callStatement + " \n");
                if (callStatement != null){
                    callStatement.close();
                    callStatement = null;
                }
            }
        }
        return valorDevuelto;
    }
    public int[] ejecutarBatch(String sql, Collection batch) throws SQLException{
        int[] rowsAffected;
        try{
            this.prepararStatement(sql);
            Iterator batchIter = batch.iterator();
            while(batchIter.hasNext()){
                Collection params = (Collection) batchIter.next();
                Iterator paramsIter = params.iterator();
                int parmIdx = 1;
                while(paramsIter.hasNext()){
                    Object param = paramsIter.next();
                    if (param != null){
                        if (param.getClass().getName().equals("Date")){
                            param = new java.sql.Date(((java.util.Date) param).getTime());
                        }
                        preparedStatement.setObject(parmIdx, param);
                    }else{
                        preparedStatement.setNull(parmIdx, Types.JAVA_OBJECT);
                    }
                    parmIdx++;
                }
                preparedStatement.addBatch();
            }
            rowsAffected = this.preparedStatement.executeBatch();
            if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this +"::executeBatch(" + sql +
                    ")::batch: " + batch + "::filasAfectadas: " + Arrays.asList(rowsAffected) + "\n");
        }finally{
            if (isAdvertenciasProcesadas()){
                rellenarAdvertencias(preparedStatement.getWarnings());
                this.preparedStatement.clearWarnings();
            }
            if (isCerrarStatementTrasEjecucion()){
                if (preparedStatement != null){
                    if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this
                            +"::executeBatch()::cerrando PreparedStatement: " + preparedStatement + " \n");
                    preparedStatement.close();
                    preparedStatement = null;
                }
            }
        }
        return rowsAffected;
    }
    public int[] ejecutarBatch(Collection batch) throws SQLException{
        int[] filasAfectadas;
        createStatement();
        try{
            Iterator batchIter = batch.iterator();
            while(batchIter.hasNext()){
                String sql = (String) batchIter.next();
                this.statement.addBatch(sql);
            }
            filasAfectadas = this.statement.executeBatch();
            if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this +"::ejecutarBatch()::batch: " +
                    batch + "::filasAfectadas: " + Arrays.asList(filasAfectadas) +"\n");
        }finally{
            if (isAdvertenciasProcesadas()){
                rellenarAdvertencias(statement.getWarnings());
                this.statement.clearWarnings();
            }
            if (isCerrarStatementTrasEjecucion()){
                if (statement != null){
                    if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this
                            +"::ejecutarBatch()::cerrando Statement: " + statement + " \n");
                    statement.close();
                    statement = null;
                }
            }
        }
        return filasAfectadas;
    }
    public int ejecutar(String sql) throws SQLException{
        int filasAfectadas = -1;
        try{
            filasAfectadas = this.getStatement(sql).executeUpdate(sql);
        }finally{
            if (isAdvertenciasProcesadas()){
                rellenarAdvertencias(statement.getWarnings());
                this.statement.clearWarnings();
            }
            if (isCerrarStatementTrasEjecucion()){
                if (statement != null){
                    if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this
                            +"::ejecutarBatch()::cerrando Statement: " + statement + " \n");
                    statement.close();
                    statement = null;
                }
            }
        }
        this.setFilasAfectadasPorTransaccion(filasAfectadasPorTransaccion + filasAfectadas);
        if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this +"::ejecutar()::sql: \n" + sql +
                "::filasAfectadas: " + filasAfectadas + "\n");
        return filasAfectadas;
    }
    public int ejecutar(String sql, Collection colParms) throws SQLException{
        int filasAfectadas = -1;
        try{
            filasAfectadas = this.getPreparedStatement(sql, colParms).executeUpdate();
        }finally{
            if (isAdvertenciasProcesadas()){
                rellenarAdvertencias(statement.getWarnings());
                this.statement.clearWarnings();
            }
            if (isCerrarStatementTrasEjecucion()){
                if (preparedStatement != null){
                    if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this
                            +"::ejecutarBatch()::cerrando PreparedStatement: " + preparedStatement + " \n");
                    preparedStatement.close();
                    preparedStatement = null;
                }
            }
        }
        this.setFilasAfectadasPorTransaccion(filasAfectadasPorTransaccion + filasAfectadas);
        if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this +"::ejecutar()::sql: \n" + sql + "                params: " + colParms + "::rowsAffected: " + filasAfectadas + "\n");
        return filasAfectadas;
    }
    /** Asignar nueva propiedad a resultSet.
     * @param resultSet New valor of property resultSet.
     *
     */
    public void setResultSet(java.sql.ResultSet resultSet) {
        this.resultSet = resultSet;
    }
    protected void createStatement() throws SQLException{
        statement = this.getConnection().createStatement(getResultadoSetType(), getConcurrencia());
        statement.setEscapeProcessing(this.getEscapeProcessing());
        statement.setFetchSize(this.getFetchLongitud());
        statement.setMaxRows(this.getMaxFilas());
        statement.setMaxFieldSize(this.getMaxLongitudCampo());
        statement.setQueryTimeout(this.getQueryTiempoLimite());
        if (this.getNombreCursor() != null){
            statement.setCursorName(this.getNombreCursor());
        }
    }
    /** Leer la propiedad de statement.
     * @return Value of property statement.
     *
     */
    public java.sql.Statement getStatement(String sql) throws SQLException{
        if (sql == null || sql.trim().length() == 0) {
            throw new SQLException("SQL String is empty or null");
        }
        int idx = -1;
        if (almacenStatements){ // Statement to be reused, otherwise must be closed and set to null
            idx = sentenciasId.indexOf(sql);
            if (idx >= 0){
                statement = (Statement) sentenciasAlmacenamiento.get(idx);
                if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this +"::===============                        getStatement() ============ encontrado almacen. statement: \n" + sql + "::" + statement + " \n");
                if (statement == null){
                    sentenciasId.remove(idx);
                    sentenciasAlmacenamiento.remove(idx); //??
                    idx = -1;
                }
            }
        }
        if (idx == -1){
            createStatement();
        }
        if (almacenStatements){
            if (idx == -1){
                idx = addAlmacenStatement(sql, statement);
                contadorSentenciasAlmacenadas.add(new Integer(1));
            }else{
// ¿Cuán a menudo fue llamada esta instrucción?
                Object cont = contadorSentenciasAlmacenadas.get(idx);
                if (cont == null){
                    contadorSentenciasAlmacenadas.add(new Integer(1));
                }else{
                    contadorSentenciasAlmacenadas.set(idx, new Integer(((Integer) cont).intValue() + 1));
                }
            }
        }
        if (isAdvertenciasProcesadas()){
            rellenarAdvertencias(statement.getWarnings());
            statement.clearWarnings();
        }
        return statement;
    }
    protected void closeResults() throws SQLException{
        if (resultSets != null){
            for (int i = 0;i < resultSets.size();i++){
                Object obj = resultSets.get(i);
                if (obj != null){
                    ((ResultSet) obj).close();
                    obj = null;
                }
            }
            resultSets = null;
        }
    }
    /** Asignar nueva propiedad a statement.
     * @param statement New valor of property statement.
     *
     */
    public void setStatement(java.sql.Statement statement) {
        this.statement = statement;
    }
    public void release(boolean conexionCerrada) throws SQLException{
        if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this +"::=============== RELEASE                ============ conexionCerrada: " + conexionCerrada + " \n");
        if (resultSet != null){
            resultSet.close();
            resultSet = null;
        }
        closeResults();
        if (!almacenStatements){
            if (statement != null){
                statement.close();
                statement = null;
            }
            if (preparedStatement != null){
                preparedStatement.close();
                preparedStatement = null;
            }
            if (callStatement != null){
                callStatement.close();
                callStatement = null;
            }
        }
        if (advertencias != null){
            advertencias.clear();
        }
        if (connection != null){
            if (conexionCerrada == true){
                borrarAlmacenStatement();
                if (proccessTransactionOnCloseConnection == ROLLBACK){
                    connection.rollback();
                }else if (proccessTransactionOnCloseConnection == COMMIT){
                    connection.commit();
                }
                connection.close();
                setConexionCerrada(true);
                connection = null;
                this.setTransaccionEnCurso(false);
                this.setConexionId("<none>");
            }else{
//no hacer nada
            }
        }
    }
    public void beginTran() throws SQLException{
        if (EJBContext == null){
            if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this +"::=============== BEGIN                    TRAN ============ anterior connectionId: " + conexionId + " \n");
            this.setFilasAfectadasPorTransaccion(0);
            this.getConnection().setAutoCommit(false);
            this.setConexionId(this.connection.toString());
            this.setTransaccionEnCurso(true);
            if (isAdvertenciasProcesadas()){
                rellenarAdvertencias(this.connection.getWarnings());
                this.connection.clearWarnings();
            }
            if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this +"::=============== BEGIN                    TRAN ============ actual connectionId: " + conexionId + " \n");
        }else{
            if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this +"::===============                    EJBContext: " + EJBContext + " \n");
        }
    }
    public void commitTran() throws SQLException{
        if (EJBContext == null){
            if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this +"::=============== COMMIT                    TRAN ============= actual connectionId: " + conexionId + " \n");
            this.getConnection().commit();
            if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this +"::===============                    COMMITTED ================\n");
            this.getConnection().setAutoCommit(true);//?? Sybase bug
            this.setTransaccionEnCurso(false);
            this.setConexionId("<none>");
            if (isAdvertenciasProcesadas()){
                rellenarAdvertencias(this.connection.getWarnings());
                this.connection.clearWarnings();
            }
        }else{
            if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this +"::===============                    EJBContext: " + EJBContext + " \n");
        }
    }
    public void rollbackTran() throws SQLException{
        if (EJBContext != null){
            try{
                if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this +"::===============                        EJBContext: " + EJBContext +".setRollbackOnly ============= connectionId: " + conexionId + " \n");
                Method m = EJBContext.getClass().getMethod("setRollbackOnly", new Class[]{});
                m.invoke(EJBContext, new Object[]{});
            }catch (InvocationTargetException ete) {
                throw new SQLException(ete.getTargetException().getMessage());
            }catch(Exception e){
                throw new SQLException(e.getMessage());
            }
        }else{
            if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this +"::===============                    ROLLBACK TRAN ============= connectionId: " + conexionId + " \n");
            this.getConnection().rollback();
            if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this +"::=============== AFTER                    ROLLBACK =========== connectionId: " + conexionId + " \n");
            this.getConnection().setAutoCommit(true);
            this.setTransaccionEnCurso(false);
            this.setConexionId("<none>");
            if (isAdvertenciasProcesadas()){
                rellenarAdvertencias(this.connection.getWarnings());
                this.connection.clearWarnings();
            }
        }
    }
    /** Leer la propiedad de nombreOrigenDatos.
     * @return Value of property nombreOrigenDatos.
     *
     */
    public String getNombreOrigenDatos() {
        return nombreOrigenDatos;
    }
    /** Asignar nueva propiedad a nombreOrigenDatos.
     * @param nombreOrigenDatos New valor of property nombreOrigenDatos.
     *
     */
    public void setNombreOrigenDatos(String nombreOrigenDatos) {
        this.nombreOrigenDatos = nombreOrigenDatos;
    }
    /** Leer la propiedad de fetchLongitud.
     * @return Value of property fetchLongitud.
     *
     */
    public int getFetchLongitud() {
        return fetchLongitud;
    }
    /** Asignar nueva propiedad a fetchLongitud.
     * @param fetchLongitud New valor of property fetchLongitud.
     *
     */
    public void setFetchLongitud(int fetchLongitud) {
        this.fetchLongitud = fetchLongitud;
    }
    /** Leer la propiedad de fetchDireccion.
     * @return Value of property fetchDireccion.
     *
     */
    public int getFetchDireccion() {
        return fetchDireccion;
    }
    /** Asignar nueva propiedad a fetchDireccion.
     * @param fetchDireccion New valor of property fetchDireccion.
     *
     */
    public void setFetchDireccion(int fetchDireccion) {
        this.fetchDireccion = fetchDireccion;
    }
    /** Leer la propiedad de queryTiempoLimite.
     * @return Value of property queryTiempoLimite.
     *
     */
    public int getQueryTiempoLimite() {
        return queryTiempoLimite;
    }
    /** Asignar nueva propiedad a queryTiempoLimite.
     * @param queryTiempoLimite New valor of property queryTiempoLimite.
     *
     */
    public void setQueryTiempoLimite(int queryTiempoLimite) {
        this.queryTiempoLimite = queryTiempoLimite;
    }
    /** Leer la propiedad de maxFilas.
     * @return Value of property maxFilas.
     *
     */
    public int getMaxFilas() {
        return maxFilas;
    }
    /** Asignar nueva propiedad a maxFilas.
     * @param maxFilas New valor of property maxFilas.
     *
     */
    public void setMaxFilas(int maxFilas) {
        this.maxFilas = maxFilas;
    }
    /** Leer la propiedad de maxLongitudCampo.
     * @return Value of property maxLongitudCampo.
     *
     */
    public int getMaxLongitudCampo() {
        return maxLongitudCampo;
    }
    /** Asignar nueva propiedad a maxLongitudCampo.
     * @param maxLongitudCampo New valor of property maxLongitudCampo.
     *
     */
    public void setMaxLongitudCampo(int maxLongitudCampo) {
        this.maxLongitudCampo = maxLongitudCampo;
    }
    /** Leer la propiedad de escapeProcessing.
     * @return Value of property escapeProcessing.
     *
     */
    public boolean getEscapeProcessing() {
        return escapeProcessing;
    }
    /** Asignar nueva propiedad a escapeProcessing.
     * @param escapeProcessing New valor of property escapeProcessing.
     *
     */
    public void setEscapeProcessing(boolean escapeProcessing) {
        this.escapeProcessing = escapeProcessing;
    }
    /** Leer la propiedad de resultadoSetType.
     * @return Value of property resultadoSetType.
     *
     */
    public int getResultadoSetType() {
        return resultadoSetType;
    }
    /** Asignar nueva propiedad a resultadoSetType.
     * @param resultadoSetType New valor of property resultadoSetType.
     *
     */
    public void setResultadoSetType(int resultadoSetType) {
        this.resultadoSetType = resultadoSetType;
    }
    /** Leer la propiedad de concurrencia.
     * @return Value of property concurrencia.
     *
     */
    public int getConcurrencia() {
        return concurrencia;
    }
    /** Asignar nueva propiedad a concurrencia.
     * @param concurrencia New valor of property concurrencia.
     *
     */
    public void setConcurrencia(int concurrencia) {
        this.concurrencia = concurrencia;
    }
    /** Leer la propiedad de conexionCerrada.
     * @return Value of property conexionCerrada.
     *
     */
    public boolean isConexionCerrada() {
        return conexionCerrada;
    }
    /** Asignar nueva propiedad a conexionCerrada.
     * @param conexionCerrada New valor of property conexionCerrada.
     *
     */
    protected void setConexionCerrada(boolean conexionCerrada) {
        this.conexionCerrada = conexionCerrada;
    }
    /** Leer la propiedad de maxFilasProcesarTransaccion.
     * @return Value of property maxFilasProcesarTransaccion.
     *
     */
    public int getMaxFilasProcesarTransaccion() {
        return maxFilasProcesarTransaccion;
    }
    /** Asignar nueva propiedad a maxFilasProcesarTransaccion.
     * @param maxFilasProcesarTransaccion New valor of property maxFilasProcesarTransaccion.
     *
     */
    public void setMaxFilasProcesarTransaccion(int maxFilasProcesarTransaccion) throws SQLException{
        if (maxFilasProcesarTransaccion < 0){
            throw new SQLException("Invalid maxRowsToProccesInTransaction value");
        }
        this.maxFilasProcesarTransaccion = maxFilasProcesarTransaccion;
    }
    /** Leer la propiedad de filasAfectadasPorTransaccion.
     * @return Value of property filasAfectadasPorTransaccion.
     *
     */
    public int getFilasAfectadasPorTransaccion() {
        return filasAfectadasPorTransaccion;
    }
    /** Asignar nueva propiedad a filasAfectadasPorTransaccion.
     * @param filasAfectadasPorTransaccion New valor of property filasAfectadasPorTransaccion.
     *
     */
    public void setFilasAfectadasPorTransaccion(int filasAfectadasPorTransaccion) throws SQLException{
        this.filasAfectadasPorTransaccion = filasAfectadasPorTransaccion;
        if (this.maxFilasProcesarTransaccion != 0 &&
                this.filasAfectadasPorTransaccion >= this.maxFilasProcesarTransaccion){
            try{
                this.commitTran();
                this.release(false);
                this.beginTran();
            }catch(SQLException e){
                this.rollbackTran();
                throw e;
            }
        }
    }
    /** Leer la propiedad de conexionProperties.
     * @return Value of property conexionProperties.
     *
     */
    public Properties getConexionProperties() {
        return conexionProperties;
    }
    /** Asignar nueva propiedad a conexionProperties.
     * @param conexionProperties New valor of property conexionProperties.
     *
     */
    public void setConexionProperties(Properties conexionProperties) {
        this.conexionProperties = conexionProperties;
    }
    /** Leer la propiedad de cerrarStatementTrasEjecucion.
     * @return Value of property cerrarStatementTrasEjecucion.
     *
     */
    public boolean isCerrarStatementTrasEjecucion() {
        return cerrarStatementTrasEjecucion;
    }
    /** Asignar nueva propiedad a cerrarStatementTrasEjecucion.
     * @param cerrarStatementTrasEjecucion New valor of property cerrarStatementTrasEjecucion.
     *
     */
    public void setCerrarStatementTrasEjecucion(boolean cerrarStatementTrasEjecucion) {
        this.cerrarStatementTrasEjecucion = cerrarStatementTrasEjecucion;
    }
    /** Leer la propiedad de conexionId.
     * @return Value of property conexionId.
     *
     */
    public String getConexionId() {
        return conexionId;
    }
    /** Asignar nueva propiedad a conexionId.
     * @param conexionId New valor of property conexionId.
     *
     */
    public void setConexionId(String conexionId) {
        this.conexionId = conexionId;
    }
    /** Leer la propiedad de transaccionEnCurso.
     * @return Value of property transaccionEnCurso.
     *
     */
    public boolean isTransaccionEnCurso() {
        return transaccionEnCurso;
    }
    /** Asignar nueva propiedad a transaccionEnCurso.
     * @param transaccionEnCurso New valor of property transaccionEnCurso.
     *
     */
    public void setTransaccionEnCurso(boolean transaccionEnCurso) {
        this.transaccionEnCurso = transaccionEnCurso;
    }
    /**
     * Leer la propiedad de debug.
     * @return Value of property debug.
     */
    public boolean isDebug() {
        return debug;
    }
    /**
     * Asignar nueva propiedad a debug.
     * @param debug New valor of property debug.
     */
    public void setDebug(boolean debug) {
        this.debug = debug;
    }
    /**
     * Leer la propiedad de resetOrigenDatos.
     * @return Value of property resetOrigenDatos.
     */
    public boolean isResetOrigenDatos() {
        return resetOrigenDatos;
    }
    /**
     * Asignar nueva propiedad a resetOrigenDatos.
     * @param resetOrigenDatos New valor of property resetOrigenDatos.
     */
    public void setResetOrigenDatos(boolean resetOrigenDatos) {
        this.resetOrigenDatos = resetOrigenDatos;
    }
    public String getMarcadorPosicion() {
        return marcadorPosicion;
    }
    public void setMarcadorPosicion(String marcadorPosicion) {
        this.marcadorPosicion = marcadorPosicion;
    }
    public int getNumeroMaximoParametros() {
        return numeroMaximoParametros;
    }
    public void setNumeroMaximoParametros(int numeroMaximoParametros) {
        this.numeroMaximoParametros = numeroMaximoParametros;
    }
    public List getAdvertencias() {
        return (advertencias == null)? new ArrayList() : advertencias;
    }
    public void setProccessWarnings(boolean advertenciasProcesadas) {
        if (advertenciasProcesadas){
            advertencias = new ArrayList();
        }else{
            advertencias.clear();
            advertencias = null;
        }
        this.advertenciasProcesadas = advertenciasProcesadas;
    }
    public boolean isAdvertenciasProcesadas() {
        return this.advertenciasProcesadas;
    }
    /** Asegúrese de leer las advertencias antes de llamar a release() */
    public void rellenarAdvertencias(SQLWarning SQLwarn){
        while (SQLwarn != null){
            MagatzemDades cd = new MagatzemDades(3);
            cd.setNomCampAmbValor(1, "message", SQLwarn.getMessage());
            cd.setNomCampAmbValor(2, "SQLState", SQLwarn.getSQLState());
            cd.setNomCampAmbValor(3, "vendorErrorCode", new Integer(SQLwarn.getErrorCode()));
            advertencias.add(cd);
            SQLwarn = SQLwarn.getNextWarning();
        }
    }
    //==========================================================================
    public boolean isAlmacenStatements() {
        return almacenStatements;
    }
    public void borrarAlmacenStatement(){
        if (sentenciasAlmacenamiento != null){
            try{
                Iterator iter = sentenciasAlmacenamiento.iterator();
                while (iter.hasNext()){
                    Object obj = iter.next();
                    if (obj != null){
                        ((Statement) obj).close();
                    }
                }
                sentenciasAlmacenamiento.clear();
                contadorSentenciasAlmacenadas.clear();
                sentenciasId.clear();
                if (!almacenStatements){
                    contadorSentenciasAlmacenadas = null;
                    sentenciasAlmacenamiento = null;
                    sentenciasId = null;
                }
            }catch (SQLException sqle){
                sqle.printStackTrace();
            }
        }
    }
    public void setAlmacenStatements(boolean almacenStatements){
        if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this +"::===============                setAlmacenStatements() ============= almacenStatements: " + almacenStatements + " \n");
        if (almacenStatements){
            if (sentenciasAlmacenamiento == null){
                sentenciasAlmacenamiento = new ArrayList(maxLongitudAlmacenamientoSentencias);
                sentenciasId = new ArrayList(maxLongitudAlmacenamientoSentencias);
                contadorSentenciasAlmacenadas = new ArrayList(maxLongitudAlmacenamientoSentencias);
            }
            setCerrarStatementTrasEjecucion(false);
        }else{
            borrarAlmacenStatement();
        }
        this.almacenStatements = almacenStatements;
    }
    public int getMaxLongitudAlmacenamientoSentencias() {
        return this.maxLongitudAlmacenamientoSentencias;
    }
    public void setMaxLongitudAlmacenamientoSentencias(int maxLongitudAlmacenamientoSentencias) {
        this.maxLongitudAlmacenamientoSentencias = maxLongitudAlmacenamientoSentencias;
    }
    protected synchronized int addAlmacenStatement(String statementId, PreparedStatement statementParaAlmacenar) throws SQLException{
        if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this +"::===============                addAlmacenStatement() ============= statementId: " + statementId + "::statementParaAlmacenar: " + statementParaAlmacenar + "\n");
        if (sentenciasId.isEmpty()){
            sentenciasId.add(statementId);
            sentenciasAlmacenamiento.add(statement);
            return 0;
        }
        int idx = sentenciasId.indexOf(statementId);
        if (idx < 0){
            if (sentenciasId.size() + 1 == maxLongitudAlmacenamientoSentencias){
// Buscar y eliminar la list a menudo requerida para las sentencias (Statement)
                int iterCont = 0;
                int idxListaSentenciasUsadasFrecuentemente = 0;
                int listaSentenciasUsadasFrecuentemente = ((Integer) contadorSentenciasAlmacenadas.get(0)).intValue();
                Iterator iter = contadorSentenciasAlmacenadas.iterator();
                while (iter.hasNext()){
                    int valorActual = ((Integer) iter.next()).intValue();
                    if (valorActual < listaSentenciasUsadasFrecuentemente){
                        listaSentenciasUsadasFrecuentemente = valorActual;
                        idxListaSentenciasUsadasFrecuentemente = iterCont;
                    }
                    iterCont++;
                }
                sentenciasId.remove(idxListaSentenciasUsadasFrecuentemente);
                if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this
                        +"::addAlmacenStatement()::cerrando PreparedStatement: " + ((Statement)
                        sentenciasAlmacenamiento.get(idxListaSentenciasUsadasFrecuentemente)) + " \n");
                ((Statement) sentenciasAlmacenamiento.get(idxListaSentenciasUsadasFrecuentemente)).close();
                sentenciasAlmacenamiento.remove(idxListaSentenciasUsadasFrecuentemente);
                contadorSentenciasAlmacenadas.remove(idxListaSentenciasUsadasFrecuentemente);
                if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this +"::===============                        addCachedStatement()::remove ============= idxListaSentenciasUsadasFrecuentemente: " + idxListaSentenciasUsadasFrecuentemente + "\n");
            }
            sentenciasId.add(statementId);
            if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this +"::===============                    addAlmacenStatement()::statementParaAlmacenar: " + statementParaAlmacenar + " " + statementParaAlmacenar.getClass() + "\n");
            if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this +"::===============                    addAlmacenStatement()::statementParaAlmacenar instanceof PreparedStatement: " + (statementParaAlmacenar instanceof PreparedStatement)
                    + "\n");
            if (statementParaAlmacenar instanceof PreparedStatement){
                sentenciasAlmacenamiento.add((PreparedStatement) statementParaAlmacenar);
            }else{
                sentenciasAlmacenamiento.add(statementParaAlmacenar);
            }
            idx = sentenciasId.size() - 1;
        } else{
// la sentencia ya está en la cache, no hacer nada
        }
        return idx;
    }
    protected synchronized int addAlmacenStatement(String statementId, Statement statementParaAlmacenar) throws SQLException{
        if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this +"::===============                addAlmacenStatement() ============= statementId: " + statementId + "::statementParaAlmacenar: " + statementParaAlmacenar + "\n");
        if (sentenciasId.isEmpty()){
            sentenciasId.add(statementId);
            sentenciasAlmacenamiento.add(statement);
            return 0;
        }
        int idx = sentenciasId.indexOf(statementId);
        if (idx < 0){
            if (sentenciasId.size() + 1 == maxLongitudAlmacenamientoSentencias){
// Buscar y eliminar la list a menudo requerida para las sentencias (Statement)
                int iterCont = 0;
                int idxListaSentenciasUsadasFrecuentemente = 0;
                int listaSentenciasUsadasFrecuentemente = ((Integer) contadorSentenciasAlmacenadas.get(0)).intValue();
                Iterator iter = contadorSentenciasAlmacenadas.iterator();
                while (iter.hasNext()){
                    int valorActual = ((Integer) iter.next()).intValue();
                    if (valorActual < listaSentenciasUsadasFrecuentemente){
                        listaSentenciasUsadasFrecuentemente = valorActual;
                        idxListaSentenciasUsadasFrecuentemente = iterCont;
                    }
                    iterCont++;
                }
                sentenciasId.remove(idxListaSentenciasUsadasFrecuentemente);
                if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this                        +"::addAlmacenStatement()::cerrando Statement: " + ((Statement) sentenciasAlmacenamiento.get(idxListaSentenciasUsadasFrecuentemente)) + "                        \n");
                ((Statement) sentenciasAlmacenamiento.get(idxListaSentenciasUsadasFrecuentemente)).close();
                sentenciasAlmacenamiento.remove(idxListaSentenciasUsadasFrecuentemente);
                contadorSentenciasAlmacenadas.remove(idxListaSentenciasUsadasFrecuentemente);
                if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this +"::===============                        addAlmacenStatement()::remove ============= idxListaSentenciasUsadasFrecuentemente: " + idxListaSentenciasUsadasFrecuentemente + "\n");
            }
            sentenciasId.add(statementId);
            if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this +"::===============                    addAlmacenStatement()::statementParaAlmacenar: " + statementParaAlmacenar + " " + statementParaAlmacenar.getClass() + "\n");
            if (debug) System.out.println("lwpf ============ " + new java.util.Date() + " " + this.getClass() + "::" + this +"::===============                    addAlmacenStatement()::statementParaAlmacenar instanceof PreparedStatement: " + (statementParaAlmacenar instanceof PreparedStatement)
                    + "\n");
            if (statementParaAlmacenar instanceof PreparedStatement){
                sentenciasAlmacenamiento.add((PreparedStatement) statementParaAlmacenar);
            }else{
                sentenciasAlmacenamiento.add(statementParaAlmacenar);
            }
            idx = sentenciasId.size() - 1;
        } else{
// la sentencia ya está en la cache, no hacer nada
        }
        return idx;
    }
    public String getCachedRowSetClassName() {
        return cachedRowSetClassName;
    }
    public void setCachedRowSetClassName(String cachedRowSetClassName) {
        this.cachedRowSetClassName = cachedRowSetClassName;
    }
    public void setCerrarResultSet(boolean cerrarResultSet) {
        this.cerrarResultSet = cerrarResultSet;
    }
    public boolean isCerrarResultSet(){
        return this.cerrarResultSet;
    }
    public String getNombreCursor() {
        return nombreCursor;
    }
    public void setNombreCursor(String nombreCursor) {
        this.nombreCursor = nombreCursor;
    }
    public char getProccessTransactionOnCloseConnection() {
        return proccessTransactionOnCloseConnection;
    }
    public void setProccessTransactionOnCloseConnection(char proccessTransactionOnCloseConnection) {
        this.proccessTransactionOnCloseConnection = proccessTransactionOnCloseConnection;
    }
    public Object getEJBContext() {
        return EJBContext;
    }
    public void setEJBContext(Object EJBContext) {
        this.EJBContext = EJBContext;
    }

}
